/* 费用流
* 1.基础概念
    费用流即最小/大费用最大流（即最大可行流中的最小/大费用）
    费用流：最大流时每条边上的可行流×该边上的费用

* 2.求解算法
    将 EK 算法中的 bfs 改为 spfa，spfa 用来求解源点 S 到 T 的最短/长路（即 S 到 T 上的最小路径费用和）
    在求最短/长路的同时找到一条增广路径，然后增加这部分的费用，直到找不到增广路径为止

    spfa不可处理负权回路，如果图中有负权回路，需要消圈

    只要当前沿着最短路径增广，则一定能求得最小费用流
*/

#define DEBUG
#pragma GCC optimize("O1,O2,O3,Ofast")
#pragma GCC optimize("no-stack-protector,unroll-loops,fast-math,inline")
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,sse4,sse4.1,sse4.2,ssse3")

#include <iostream>
#include <sstream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 5010, M = 100010, INF = 0x3f3f3f3f;
int n, m, S, T;
int h[N], e[M], ne[M], c[M], w[M], idx; //容量 费用
int incf[N]; // incf[i]表示从源点走到i点的可行最大流量,取增广路径上的容量最小的值
int q[N],pre[N], d[N]; //pre[]:每个节点的最短路(S->T)的前驱边 d[]:每个节点到源点的最短费用
bool st[N]; //判重

void AddEdge(int a, int b, int cc, int ww)
{
    e[idx] = b, c[idx] = cc, w[idx]=ww, ne[idx] = h[a], h[a] = idx++;
    e[idx] = a, c[idx] = 0, w[idx]=-ww, ne[idx] = h[b], h[b] = idx++;
}

bool spfa() //是否存在最短增广路
{
    int hh = 0, tt = 0;
    memset(d, 0x3f, sizeof d);
    memset(incf, 0, sizeof incf );
    //memset(st, 0, sizeof st);
    q[tt++] = S, d[S] = 0, incf[S] = INF;
    while(hh != tt) 
    {
        int u = q[hh++];
        if(hh == N) hh = 0;
        st[u] = false;
        for(int i=h[u]; ~i; i=ne[i])
        {
            int v=e[i]; 
            if(d[v]>d[u]+w[i] && c[i])
            {
                d[v]=d[u]+w[i];
                pre[v]=i; //从当前边继续搜索
                incf[v]=min(c[i], incf[u]);
                if(!st[v])
                {
                    q[tt++]=v;
                    if(tt==N) tt=0;
                    st[v]=true; //如果之前没有访问过，则置已访问，除非有多条边可指向v，即在队列中有多次入队
                }
            }
        }
    }
    return incf[T] > 0;
}

void EK(int &flow,int &cost) //EK 算法求最小费用流
{
    flow = cost = 0;
    while(spfa())
    {
        int t = incf[T]; //当前最短增广路的最大流量
        flow += t, cost += t*d[T]; ////累加最大流和最小费用
        for(int i=T; i!=S; i=e[pre[i]^1]) //将这条增广路径删掉
        {
            c[pre[i]]-=t;
            c[pre[i]^1]+=t;
        }
    }
}

signed main()
{
    #ifdef DEBUG
        freopen("./in.txt","r",stdin);
    #else
        ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    #endif
    memset(h, -1, sizeof h);

    cin >> n >> m >> S >> T;

    while(m--)
    {
        int a, b, c, d; cin >> a >> b >> c >> d;
        AddEdge(a, b, c, d);
    }

    int flow, cost;
    EK(flow, cost);
    printf("%d %d\n", flow, cost);

    return 0;
}